Chip 2007 January, February, March & April/Chip-Cover-CD-2007-02.iso/Pakiet bezpieczenstwa/mini Pentoo LiveCD 2006.1/mpentoo-2006.1.iso/livecd.squashfs/usr/lib/python2.4/test/test_trace.pyc

Python Compiled Bytecode | 2005-10-18 | 20.8 KB | 791 lines

# Source Generated with Decompyle++
# File: in.pyc (Python 2.4)

from test import test_support
import unittest
import sys
import difflib

def basic():
    return 1

basic.events = [
    (0, 'call'),
    (1, 'line'),
    (1, 'return')]

def arigo_example():
    x = 1
    del x
    while 0:
        pass
    x = 1

arigo_example.events = [
    (0, 'call'),
    (1, 'line'),
    (2, 'line'),
    (3, 'line'),
    (5, 'line'),
    (5, 'return')]

def one_instr_line():
    x = 1
    del x
    x = 1

one_instr_line.events = [
    (0, 'call'),
    (1, 'line'),
    (2, 'line'),
    (3, 'line'),
    (3, 'return')]

def no_pop_tops():
    x = 1
    for a in range(2):
        if a:
            x = 1
            continue
        x = 1


no_pop_tops.events = [
    (0, 'call'),
    (1, 'line'),
    (2, 'line'),
    (3, 'line'),
    (6, 'line'),
    (2, 'line'),
    (3, 'line'),
    (4, 'line'),
    (2, 'line'),
    (2, 'return')]

def no_pop_blocks():
    while 0:
        bla
    x = 1

no_pop_blocks.events = [
    (0, 'call'),
    (1, 'line'),
    (3, 'line'),
    (3, 'return')]

def called():
    x = 1


def call():
    called()

call.events = [
    (0, 'call'),
    (1, 'line'),
    (-3, 'call'),
    (-2, 'line'),
    (-2, 'return'),
    (1, 'return')]

def raises():
    raise Exception


def test_raise():

    try:
        raises()
    except Exception:
        exc = None
        x = 1


test_raise.events = [
    (0, 'call'),
    (1, 'line'),
    (2, 'line'),
    (-3, 'call'),
    (-2, 'line'),
    (-2, 'exception'),
    (-2, 'return'),
    (2, 'exception'),
    (3, 'line'),
    (4, 'line'),
    (4, 'return')]

def _settrace_and_return(tracefunc):
    sys.settrace(tracefunc)
    sys._getframe().f_back.f_trace = tracefunc


def settrace_and_return(tracefunc):
    _settrace_and_return(tracefunc)

settrace_and_return.events = [
    (1, 'return')]

def _settrace_and_raise(tracefunc):
    sys.settrace(tracefunc)
    sys._getframe().f_back.f_trace = tracefunc
    raise RuntimeError


def settrace_and_raise(tracefunc):

    try:
        _settrace_and_raise(tracefunc)
    except RuntimeError:
        exc = None


settrace_and_raise.events = [
    (2, 'exception'),
    (3, 'line'),
    (4, 'line'),
    (4, 'return')]

def ireturn_example():
    a = 5
    b = 5
    if a == b:
        b = a + 1


ireturn_example.events = [
    (0, 'call'),
    (1, 'line'),
    (2, 'line'),
    (3, 'line'),
    (4, 'line'),
    (4, 'return')]

def tightloop_example():
    items = range(0, 3)

    try:
        i = 0
        while None:
            b = items[i]
            i += 1
    except IndexError:
        pass


tightloop_example.events = [
    (0, 'call'),
    (1, 'line'),
    (2, 'line'),
    (3, 'line'),
    (4, 'line'),
    (5, 'line'),
    (5, 'line'),
    (5, 'line'),
    (5, 'line'),
    (5, 'exception'),
    (6, 'line'),
    (7, 'line'),
    (7, 'return')]

def tighterloop_example():
    items = range(1, 4)

    try:
        i = 0
        while None:
            i = items[i]
    except IndexError:
        pass


tighterloop_example.events = [
    (0, 'call'),
    (1, 'line'),
    (2, 'line'),
    (3, 'line'),
    (4, 'line'),
    (4, 'line'),
    (4, 'line'),
    (4, 'line'),
    (4, 'exception'),
    (5, 'line'),
    (6, 'line'),
    (6, 'return')]

class Tracer:

    def __init__(self):
        self.events = []


    def trace(self, frame, event, arg):
        self.events.append((frame.f_lineno, event))
        return self.trace



class TraceTestCase(unittest.TestCase):

    def compare_events(self, line_offset, events, expected_events):
        events = [ (l - line_offset, e) for l, e in events ]


    def run_test(self, func):
        tracer = Tracer()
        sys.settrace(tracer.trace)
        func()
        sys.settrace(None)
        self.compare_events(func.func_code.co_firstlineno, tracer.events, func.events)


    def run_test2(self, func):
        tracer = Tracer()
        func(tracer.trace)
        sys.settrace(None)
        self.compare_events(func.func_code.co_firstlineno, tracer.events, func.events)


    def test_01_basic(self):
        self.run_test(basic)


    def test_02_arigo(self):
        self.run_test(arigo_example)


    def test_03_one_instr(self):
        self.run_test(one_instr_line)


    def test_04_no_pop_blocks(self):
        self.run_test(no_pop_blocks)


    def test_05_no_pop_tops(self):
        self.run_test(no_pop_tops)


    def test_06_call(self):
        self.run_test(call)


    def test_07_raise(self):
        self.run_test(test_raise)


    def test_08_settrace_and_return(self):
        self.run_test2(settrace_and_return)


    def test_09_settrace_and_raise(self):
        self.run_test2(settrace_and_raise)


    def test_10_ireturn(self):
        self.run_test(ireturn_example)


    def test_11_tightloop(self):
        self.run_test(tightloop_example)


    def test_12_tighterloop(self):
        self.run_test(tighterloop_example)



class RaisingTraceFuncTestCase(unittest.TestCase):

    def trace(self, frame, event, arg):
        '''A trace function that raises an exception in response to a
        specific trace event.'''
        if event == self.raiseOnEvent:
            raise ValueError
        else:
            return self.trace


    def f(self):
        """The function to trace; raises an exception if that's the case
        we're testing, so that the 'exception' trace event fires."""
        if self.raiseOnEvent == 'exception':
            x = 0
            y = 1 / x
        else:
            return 1


    def run_test_for_event(self, event):
        '''Tests that an exception raised in response to the given event is
        handled OK.'''
        self.raiseOnEvent = event

        try:
            for i in xrange(sys.getrecursionlimit() + 1):
                sys.settrace(self.trace)

                try:
                    self.f()
                except ValueError:
                    continue

                self.fail('exception not thrown!')
        except RuntimeError:
            self.fail('recursion counter not reset')



    def test_call(self):
        self.run_test_for_event('call')


    def test_line(self):
        self.run_test_for_event('line')


    def test_return(self):
        self.run_test_for_event('return')


    def test_exception(self):
        self.run_test_for_event('exception')


    def test_trash_stack(self):

        def f():
            for i in range(5):
                print i



        def g(frame, why, extra):
            if why == 'line' and frame.f_lineno == f.func_code.co_firstlineno + 2:
                raise RuntimeError, 'i am crashing'

            return g

        sys.settrace(g)

        try:
            f()
        except RuntimeError:
            import gc
            gc.collect()

        self.fail('exception not propagated')



class JumpTracer:
    """Defines a trace function that jumps from one place to another,
    with the source and destination lines of the jump being defined by
    the 'jump' property of the function under test."""

    def __init__(self, function):
        self.function = function
        self.jumpFrom = function.jump[0]
        self.jumpTo = function.jump[1]
        self.done = False


    def trace(self, frame, event, arg):
        if not (self.done) and frame.f_code == self.function.func_code:
            firstLine = frame.f_code.co_firstlineno
            if frame.f_lineno == firstLine + self.jumpFrom:

                try:
                    frame.f_lineno = firstLine + self.jumpTo
                except TypeError:
                    frame.f_lineno = self.jumpTo

                self.done = True


        return self.trace



def jump_simple_forwards(output):
    output.append(1)
    output.append(2)
    output.append(3)

jump_simple_forwards.jump = (1, 3)
jump_simple_forwards.output = [
    3]

def jump_simple_backwards(output):
    output.append(1)
    output.append(2)

jump_simple_backwards.jump = (2, 1)
jump_simple_backwards.output = [
    1,
    1,
    2]

def jump_out_of_block_forwards(output):
    for i in (1, 2):
        output.append(2)
        for j in [
            3]:
            output.append(4)


    output.append(5)

jump_out_of_block_forwards.jump = (3, 5)
jump_out_of_block_forwards.output = [
    2,
    5]

def jump_out_of_block_backwards(output):
    output.append(1)
    for i in [
        1]:
        output.append(3)
        for j in [
            2]:
            output.append(5)

        output.append(6)

    output.append(7)

jump_out_of_block_backwards.jump = (6, 1)
jump_out_of_block_backwards.output = [
    1,
    3,
    5,
    1,
    3,
    5,
    6,
    7]

def jump_to_codeless_line(output):
    output.append(1)
    output.append(3)

jump_to_codeless_line.jump = (1, 2)
jump_to_codeless_line.output = [
    3]

def jump_to_same_line(output):
    output.append(1)
    output.append(2)
    output.append(3)

jump_to_same_line.jump = (2, 2)
jump_to_same_line.output = [
    1,
    2,
    3]

def jump_in_nested_finally(output):

    try:
        output.append(2)
    finally:
        output.append(4)

        try:
            output.append(6)
        finally:
            output.append(8)

        output.append(9)


jump_in_nested_finally.jump = (4, 9)
jump_in_nested_finally.output = [
    2,
    9]

def no_jump_too_far_forwards(output):

    try:
        output.append(2)
        output.append(3)
    except ValueError:
        e = None
        output.append('after' in str(e))


no_jump_too_far_forwards.jump = (3, 6)
no_jump_too_far_forwards.output = [
    2,
    True]

def no_jump_too_far_backwards(output):

    try:
        output.append(2)
        output.append(3)
    except ValueError:
        e = None
        output.append('before' in str(e))


no_jump_too_far_backwards.jump = (3, -1)
no_jump_too_far_backwards.output = [
    2,
    True]

def no_jump_to_except_1(output):

    try:
        output.append(2)
    except:
        e = sys.exc_info()[1]
        output.append('except' in str(e))


no_jump_to_except_1.jump = (2, 3)
no_jump_to_except_1.output = [
    True]

def no_jump_to_except_2(output):

    try:
        output.append(2)
    except ValueError:
        e = sys.exc_info()[1]
        output.append('except' in str(e))


no_jump_to_except_2.jump = (2, 3)
no_jump_to_except_2.output = [
    True]

def no_jump_to_except_3(output):

    try:
        output.append(2)
    except ValueError:
        e = None
        output.append('except' in str(e))


no_jump_to_except_3.jump = (2, 3)
no_jump_to_except_3.output = [
    True]

def no_jump_to_except_4(output):

    try:
        output.append(2)
    except (ValueError, RuntimeError):
        e = None
        output.append('except' in str(e))


no_jump_to_except_4.jump = (2, 3)
no_jump_to_except_4.output = [
    True]

def no_jump_forwards_into_block(output):

    try:
        output.append(2)
        for i in (1, 2):
            output.append(4)
    except ValueError:
        e = None
        output.append('into' in str(e))


no_jump_forwards_into_block.jump = (2, 4)
no_jump_forwards_into_block.output = [
    True]

def no_jump_backwards_into_block(output):

    try:
        for i in (1, 2):
            output.append(3)

        output.append(4)
    except ValueError:
        e = None
        output.append('into' in str(e))


no_jump_backwards_into_block.jump = (4, 3)
no_jump_backwards_into_block.output = [
    3,
    3,
    True]

def no_jump_into_finally_block(output):

    try:

        try:
            output.append(3)
            x = 1
        finally:
            output.append(6)

    except ValueError:
        e = None
        output.append('finally' in str(e))


no_jump_into_finally_block.jump = (4, 6)
no_jump_into_finally_block.output = [
    3,
    6,
    True]

def no_jump_out_of_finally_block(output):

    try:

        try:
            output.append(3)
        finally:
            output.append(5)
            output.append(6)

    except ValueError:
        e = None
        output.append('finally' in str(e))


no_jump_out_of_finally_block.jump = (5, 1)
no_jump_out_of_finally_block.output = [
    3,
    True]

def no_jump_to_non_integers(output):

    try:
        output.append(2)
    except ValueError:
        e = None
        output.append('integer' in str(e))


no_jump_to_non_integers.jump = (2, 'Spam')
no_jump_to_non_integers.output = [
    True]

def no_jump_without_trace_function():

    try:
        previous_frame = sys._getframe().f_back
        previous_frame.f_lineno = previous_frame.f_lineno
    except ValueError:
        e = None
        if 'trace' not in str(e):
            raise

    except:
        'trace' not in str(e)

    raise RuntimeError, 'Trace-function-less jump failed to fail'


class JumpTestCase(unittest.TestCase):

    def compare_jump_output(self, expected, received):
        if received != expected:
            self.fail("Outputs don't match:\n" + 'Expected: ' + repr(expected) + '\n' + 'Received: ' + repr(received))



    def run_test(self, func):
        tracer = JumpTracer(func)
        sys.settrace(tracer.trace)
        output = []
        func(output)
        sys.settrace(None)
        self.compare_jump_output(func.output, output)


    def test_01_jump_simple_forwards(self):
        self.run_test(jump_simple_forwards)


    def test_02_jump_simple_backwards(self):
        self.run_test(jump_simple_backwards)


    def test_03_jump_out_of_block_forwards(self):
        self.run_test(jump_out_of_block_forwards)


    def test_04_jump_out_of_block_backwards(self):
        self.run_test(jump_out_of_block_backwards)


    def test_05_jump_to_codeless_line(self):
        self.run_test(jump_to_codeless_line)


    def test_06_jump_to_same_line(self):
        self.run_test(jump_to_same_line)


    def test_07_jump_in_nested_finally(self):
        self.run_test(jump_in_nested_finally)


    def test_08_no_jump_too_far_forwards(self):
        self.run_test(no_jump_too_far_forwards)


    def test_09_no_jump_too_far_backwards(self):
        self.run_test(no_jump_too_far_backwards)


    def test_10_no_jump_to_except_1(self):
        self.run_test(no_jump_to_except_1)


    def test_11_no_jump_to_except_2(self):
        self.run_test(no_jump_to_except_2)


    def test_12_no_jump_to_except_3(self):
        self.run_test(no_jump_to_except_3)


    def test_13_no_jump_to_except_4(self):
        self.run_test(no_jump_to_except_4)


    def test_14_no_jump_forwards_into_block(self):
        self.run_test(no_jump_forwards_into_block)


    def test_15_no_jump_backwards_into_block(self):
        self.run_test(no_jump_backwards_into_block)


    def test_16_no_jump_into_finally_block(self):
        self.run_test(no_jump_into_finally_block)


    def test_17_no_jump_out_of_finally_block(self):
        self.run_test(no_jump_out_of_finally_block)


    def test_18_no_jump_to_non_integers(self):
        self.run_test(no_jump_to_non_integers)


    def test_19_no_jump_without_trace_function(self):
        no_jump_without_trace_function()



def test_main():
    test_support.run_unittest(TraceTestCase, RaisingTraceFuncTestCase, JumpTestCase)

if __name__ == '__main__':
    test_main()